// Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

// automatically generated by tools/bindgen.sh

#![allow(
    non_camel_case_types,
    non_upper_case_globals,
    dead_code,
    non_snake_case,
    clippy::ptr_as_ptr,
    clippy::undocumented_unsafe_blocks,
    clippy::cast_lossless,
    missing_debug_implementations,
    clippy::tests_outside_test_module
)]

pub const IFNAMSIZ: u32 = 16;
pub const IFALIASZ: u32 = 256;
pub const IF_GET_IFACE: u32 = 1;
pub const IF_GET_PROTO: u32 = 2;
pub const IF_IFACE_V35: u32 = 4096;
pub const IF_IFACE_V24: u32 = 4097;
pub const IF_IFACE_X21: u32 = 4098;
pub const IF_IFACE_T1: u32 = 4099;
pub const IF_IFACE_E1: u32 = 4100;
pub const IF_IFACE_SYNC_SERIAL: u32 = 4101;
pub const IF_IFACE_X21D: u32 = 4102;
pub const IF_PROTO_HDLC: u32 = 8192;
pub const IF_PROTO_PPP: u32 = 8193;
pub const IF_PROTO_CISCO: u32 = 8194;
pub const IF_PROTO_FR: u32 = 8195;
pub const IF_PROTO_FR_ADD_PVC: u32 = 8196;
pub const IF_PROTO_FR_DEL_PVC: u32 = 8197;
pub const IF_PROTO_X25: u32 = 8198;
pub const IF_PROTO_HDLC_ETH: u32 = 8199;
pub const IF_PROTO_FR_ADD_ETH_PVC: u32 = 8200;
pub const IF_PROTO_FR_DEL_ETH_PVC: u32 = 8201;
pub const IF_PROTO_FR_PVC: u32 = 8202;
pub const IF_PROTO_FR_ETH_PVC: u32 = 8203;
pub const IF_PROTO_RAW: u32 = 8204;
pub const IFHWADDRLEN: u32 = 6;
pub type sa_family_t = ::std::os::raw::c_ushort;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct sockaddr {
    pub sa_family: sa_family_t,
    pub sa_data: [::std::os::raw::c_char; 14usize],
}
#[test]
fn bindgen_test_layout_sockaddr() {
    assert_eq!(
        ::std::mem::size_of::<sockaddr>(),
        16usize,
        concat!("Size of: ", stringify!(sockaddr))
    );
    assert_eq!(
        ::std::mem::align_of::<sockaddr>(),
        2usize,
        concat!("Alignment of ", stringify!(sockaddr))
    );
    fn test_field_sa_family() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<sockaddr>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).sa_family) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(sockaddr),
                "::",
                stringify!(sa_family)
            )
        );
    }
    test_field_sa_family();
    fn test_field_sa_data() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<sockaddr>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).sa_data) as usize - ptr as usize
            },
            2usize,
            concat!(
                "Offset of field: ",
                stringify!(sockaddr),
                "::",
                stringify!(sa_data)
            )
        );
    }
    test_field_sa_data();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct sync_serial_settings {
    pub clock_rate: ::std::os::raw::c_uint,
    pub clock_type: ::std::os::raw::c_uint,
    pub loopback: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_sync_serial_settings() {
    assert_eq!(
        ::std::mem::size_of::<sync_serial_settings>(),
        12usize,
        concat!("Size of: ", stringify!(sync_serial_settings))
    );
    assert_eq!(
        ::std::mem::align_of::<sync_serial_settings>(),
        4usize,
        concat!("Alignment of ", stringify!(sync_serial_settings))
    );
    fn test_field_clock_rate() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<sync_serial_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).clock_rate) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(sync_serial_settings),
                "::",
                stringify!(clock_rate)
            )
        );
    }
    test_field_clock_rate();
    fn test_field_clock_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<sync_serial_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).clock_type) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(sync_serial_settings),
                "::",
                stringify!(clock_type)
            )
        );
    }
    test_field_clock_type();
    fn test_field_loopback() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<sync_serial_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).loopback) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(sync_serial_settings),
                "::",
                stringify!(loopback)
            )
        );
    }
    test_field_loopback();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct te1_settings {
    pub clock_rate: ::std::os::raw::c_uint,
    pub clock_type: ::std::os::raw::c_uint,
    pub loopback: ::std::os::raw::c_ushort,
    pub slot_map: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_te1_settings() {
    assert_eq!(
        ::std::mem::size_of::<te1_settings>(),
        16usize,
        concat!("Size of: ", stringify!(te1_settings))
    );
    assert_eq!(
        ::std::mem::align_of::<te1_settings>(),
        4usize,
        concat!("Alignment of ", stringify!(te1_settings))
    );
    fn test_field_clock_rate() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<te1_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).clock_rate) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(te1_settings),
                "::",
                stringify!(clock_rate)
            )
        );
    }
    test_field_clock_rate();
    fn test_field_clock_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<te1_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).clock_type) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(te1_settings),
                "::",
                stringify!(clock_type)
            )
        );
    }
    test_field_clock_type();
    fn test_field_loopback() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<te1_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).loopback) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(te1_settings),
                "::",
                stringify!(loopback)
            )
        );
    }
    test_field_loopback();
    fn test_field_slot_map() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<te1_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).slot_map) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(te1_settings),
                "::",
                stringify!(slot_map)
            )
        );
    }
    test_field_slot_map();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct raw_hdlc_proto {
    pub encoding: ::std::os::raw::c_ushort,
    pub parity: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_raw_hdlc_proto() {
    assert_eq!(
        ::std::mem::size_of::<raw_hdlc_proto>(),
        4usize,
        concat!("Size of: ", stringify!(raw_hdlc_proto))
    );
    assert_eq!(
        ::std::mem::align_of::<raw_hdlc_proto>(),
        2usize,
        concat!("Alignment of ", stringify!(raw_hdlc_proto))
    );
    fn test_field_encoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<raw_hdlc_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(raw_hdlc_proto),
                "::",
                stringify!(encoding)
            )
        );
    }
    test_field_encoding();
    fn test_field_parity() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<raw_hdlc_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).parity) as usize - ptr as usize
            },
            2usize,
            concat!(
                "Offset of field: ",
                stringify!(raw_hdlc_proto),
                "::",
                stringify!(parity)
            )
        );
    }
    test_field_parity();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct fr_proto {
    pub t391: ::std::os::raw::c_uint,
    pub t392: ::std::os::raw::c_uint,
    pub n391: ::std::os::raw::c_uint,
    pub n392: ::std::os::raw::c_uint,
    pub n393: ::std::os::raw::c_uint,
    pub lmi: ::std::os::raw::c_ushort,
    pub dce: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_fr_proto() {
    assert_eq!(
        ::std::mem::size_of::<fr_proto>(),
        24usize,
        concat!("Size of: ", stringify!(fr_proto))
    );
    assert_eq!(
        ::std::mem::align_of::<fr_proto>(),
        4usize,
        concat!("Alignment of ", stringify!(fr_proto))
    );
    fn test_field_t391() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).t391) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto),
                "::",
                stringify!(t391)
            )
        );
    }
    test_field_t391();
    fn test_field_t392() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).t392) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto),
                "::",
                stringify!(t392)
            )
        );
    }
    test_field_t392();
    fn test_field_n391() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).n391) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto),
                "::",
                stringify!(n391)
            )
        );
    }
    test_field_n391();
    fn test_field_n392() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).n392) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto),
                "::",
                stringify!(n392)
            )
        );
    }
    test_field_n392();
    fn test_field_n393() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).n393) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto),
                "::",
                stringify!(n393)
            )
        );
    }
    test_field_n393();
    fn test_field_lmi() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).lmi) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto),
                "::",
                stringify!(lmi)
            )
        );
    }
    test_field_lmi();
    fn test_field_dce() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dce) as usize - ptr as usize
            },
            22usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto),
                "::",
                stringify!(dce)
            )
        );
    }
    test_field_dce();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct fr_proto_pvc {
    pub dlci: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_fr_proto_pvc() {
    assert_eq!(
        ::std::mem::size_of::<fr_proto_pvc>(),
        4usize,
        concat!("Size of: ", stringify!(fr_proto_pvc))
    );
    assert_eq!(
        ::std::mem::align_of::<fr_proto_pvc>(),
        4usize,
        concat!("Alignment of ", stringify!(fr_proto_pvc))
    );
    fn test_field_dlci() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto_pvc>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dlci) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto_pvc),
                "::",
                stringify!(dlci)
            )
        );
    }
    test_field_dlci();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct fr_proto_pvc_info {
    pub dlci: ::std::os::raw::c_uint,
    pub master: [::std::os::raw::c_char; 16usize],
}
#[test]
fn bindgen_test_layout_fr_proto_pvc_info() {
    assert_eq!(
        ::std::mem::size_of::<fr_proto_pvc_info>(),
        20usize,
        concat!("Size of: ", stringify!(fr_proto_pvc_info))
    );
    assert_eq!(
        ::std::mem::align_of::<fr_proto_pvc_info>(),
        4usize,
        concat!("Alignment of ", stringify!(fr_proto_pvc_info))
    );
    fn test_field_dlci() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto_pvc_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dlci) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto_pvc_info),
                "::",
                stringify!(dlci)
            )
        );
    }
    test_field_dlci();
    fn test_field_master() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fr_proto_pvc_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).master) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(fr_proto_pvc_info),
                "::",
                stringify!(master)
            )
        );
    }
    test_field_master();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct cisco_proto {
    pub interval: ::std::os::raw::c_uint,
    pub timeout: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_cisco_proto() {
    assert_eq!(
        ::std::mem::size_of::<cisco_proto>(),
        8usize,
        concat!("Size of: ", stringify!(cisco_proto))
    );
    assert_eq!(
        ::std::mem::align_of::<cisco_proto>(),
        4usize,
        concat!("Alignment of ", stringify!(cisco_proto))
    );
    fn test_field_interval() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<cisco_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).interval) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(cisco_proto),
                "::",
                stringify!(interval)
            )
        );
    }
    test_field_interval();
    fn test_field_timeout() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<cisco_proto>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(cisco_proto),
                "::",
                stringify!(timeout)
            )
        );
    }
    test_field_timeout();
}
pub const net_device_flags_IFF_UP: net_device_flags = 1;
pub const net_device_flags_IFF_BROADCAST: net_device_flags = 2;
pub const net_device_flags_IFF_DEBUG: net_device_flags = 4;
pub const net_device_flags_IFF_LOOPBACK: net_device_flags = 8;
pub const net_device_flags_IFF_POINTOPOINT: net_device_flags = 16;
pub const net_device_flags_IFF_NOTRAILERS: net_device_flags = 32;
pub const net_device_flags_IFF_RUNNING: net_device_flags = 64;
pub const net_device_flags_IFF_NOARP: net_device_flags = 128;
pub const net_device_flags_IFF_PROMISC: net_device_flags = 256;
pub const net_device_flags_IFF_ALLMULTI: net_device_flags = 512;
pub const net_device_flags_IFF_MASTER: net_device_flags = 1024;
pub const net_device_flags_IFF_SLAVE: net_device_flags = 2048;
pub const net_device_flags_IFF_MULTICAST: net_device_flags = 4096;
pub const net_device_flags_IFF_PORTSEL: net_device_flags = 8192;
pub const net_device_flags_IFF_AUTOMEDIA: net_device_flags = 16384;
pub const net_device_flags_IFF_DYNAMIC: net_device_flags = 32768;
pub const net_device_flags_IFF_LOWER_UP: net_device_flags = 65536;
pub const net_device_flags_IFF_DORMANT: net_device_flags = 131072;
pub const net_device_flags_IFF_ECHO: net_device_flags = 262144;
/// enum net_device_flags - &struct net_device flags
///
/// These are the &struct net_device flags, they can be set by drivers, the
/// kernel and some can be triggered by userspace. Userspace can query and
/// set these flags using userspace utilities but there is also a sysfs
/// entry available for all dev flags which can be queried and set. These flags
/// are shared for all types of net_devices. The sysfs entries are available
/// via /sys/class/net/<dev>/flags. Flags which can be toggled through sysfs
/// are annotated below, note that only a few flags can be toggled and some
/// other flags are always preserved from the original net_device flags
/// even if you try to set them via sysfs. Flags which are always preserved
/// are kept under the flag grouping @IFF_VOLATILE. Flags which are __volatile__
/// are annotated below as such.
///
/// You should have a pretty good reason to be extending these flags.
///
/// @IFF_UP: interface is up. Can be toggled through sysfs.
/// @IFF_BROADCAST: broadcast address valid. Volatile.
/// @IFF_DEBUG: turn on debugging. Can be toggled through sysfs.
/// @IFF_LOOPBACK: is a loopback net. Volatile.
/// @IFF_POINTOPOINT: interface is has p-p link. Volatile.
/// @IFF_NOTRAILERS: avoid use of trailers. Can be toggled through sysfs.
/// 	Volatile.
/// @IFF_RUNNING: interface RFC2863 OPER_UP. Volatile.
/// @IFF_NOARP: no ARP protocol. Can be toggled through sysfs. Volatile.
/// @IFF_PROMISC: receive all packets. Can be toggled through sysfs.
/// @IFF_ALLMULTI: receive all multicast packets. Can be toggled through
/// 	sysfs.
/// @IFF_MASTER: master of a load balancer. Volatile.
/// @IFF_SLAVE: slave of a load balancer. Volatile.
/// @IFF_MULTICAST: Supports multicast. Can be toggled through sysfs.
/// @IFF_PORTSEL: can set media type. Can be toggled through sysfs.
/// @IFF_AUTOMEDIA: auto media select active. Can be toggled through sysfs.
/// @IFF_DYNAMIC: dialup device with changing addresses. Can be toggled
/// 	through sysfs.
/// @IFF_LOWER_UP: driver signals L1 up. Volatile.
/// @IFF_DORMANT: driver signals dormant. Volatile.
/// @IFF_ECHO: echo sent packets. Volatile.
pub type net_device_flags = ::std::os::raw::c_uint;
pub const IF_OPER_UNKNOWN: _bindgen_ty_4 = 0;
pub const IF_OPER_NOTPRESENT: _bindgen_ty_4 = 1;
pub const IF_OPER_DOWN: _bindgen_ty_4 = 2;
pub const IF_OPER_LOWERLAYERDOWN: _bindgen_ty_4 = 3;
pub const IF_OPER_TESTING: _bindgen_ty_4 = 4;
pub const IF_OPER_DORMANT: _bindgen_ty_4 = 5;
pub const IF_OPER_UP: _bindgen_ty_4 = 6;
pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
pub const IF_LINK_MODE_DEFAULT: _bindgen_ty_5 = 0;
pub const IF_LINK_MODE_DORMANT: _bindgen_ty_5 = 1;
pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct ifmap {
    pub mem_start: ::std::os::raw::c_ulong,
    pub mem_end: ::std::os::raw::c_ulong,
    pub base_addr: ::std::os::raw::c_ushort,
    pub irq: ::std::os::raw::c_uchar,
    pub dma: ::std::os::raw::c_uchar,
    pub port: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_ifmap() {
    assert_eq!(
        ::std::mem::size_of::<ifmap>(),
        24usize,
        concat!("Size of: ", stringify!(ifmap))
    );
    assert_eq!(
        ::std::mem::align_of::<ifmap>(),
        8usize,
        concat!("Alignment of ", stringify!(ifmap))
    );
    fn test_field_mem_start() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifmap>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).mem_start) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifmap),
                "::",
                stringify!(mem_start)
            )
        );
    }
    test_field_mem_start();
    fn test_field_mem_end() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifmap>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).mem_end) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(ifmap),
                "::",
                stringify!(mem_end)
            )
        );
    }
    test_field_mem_end();
    fn test_field_base_addr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifmap>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).base_addr) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(ifmap),
                "::",
                stringify!(base_addr)
            )
        );
    }
    test_field_base_addr();
    fn test_field_irq() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifmap>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).irq) as usize - ptr as usize
            },
            18usize,
            concat!(
                "Offset of field: ",
                stringify!(ifmap),
                "::",
                stringify!(irq)
            )
        );
    }
    test_field_irq();
    fn test_field_dma() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifmap>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dma) as usize - ptr as usize
            },
            19usize,
            concat!(
                "Offset of field: ",
                stringify!(ifmap),
                "::",
                stringify!(dma)
            )
        );
    }
    test_field_dma();
    fn test_field_port() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifmap>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(ifmap),
                "::",
                stringify!(port)
            )
        );
    }
    test_field_port();
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct if_settings {
    pub type_: ::std::os::raw::c_uint,
    pub size: ::std::os::raw::c_uint,
    pub ifs_ifsu: if_settings__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union if_settings__bindgen_ty_1 {
    pub raw_hdlc: *mut raw_hdlc_proto,
    pub cisco: *mut cisco_proto,
    pub fr: *mut fr_proto,
    pub fr_pvc: *mut fr_proto_pvc,
    pub fr_pvc_info: *mut fr_proto_pvc_info,
    pub sync: *mut sync_serial_settings,
    pub te1: *mut te1_settings,
}
#[test]
fn bindgen_test_layout_if_settings__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<if_settings__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(if_settings__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<if_settings__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(if_settings__bindgen_ty_1))
    );
    fn test_field_raw_hdlc() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).raw_hdlc) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings__bindgen_ty_1),
                "::",
                stringify!(raw_hdlc)
            )
        );
    }
    test_field_raw_hdlc();
    fn test_field_cisco() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).cisco) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings__bindgen_ty_1),
                "::",
                stringify!(cisco)
            )
        );
    }
    test_field_cisco();
    fn test_field_fr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings__bindgen_ty_1),
                "::",
                stringify!(fr)
            )
        );
    }
    test_field_fr();
    fn test_field_fr_pvc() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fr_pvc) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings__bindgen_ty_1),
                "::",
                stringify!(fr_pvc)
            )
        );
    }
    test_field_fr_pvc();
    fn test_field_fr_pvc_info() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fr_pvc_info) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings__bindgen_ty_1),
                "::",
                stringify!(fr_pvc_info)
            )
        );
    }
    test_field_fr_pvc_info();
    fn test_field_sync() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).sync) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings__bindgen_ty_1),
                "::",
                stringify!(sync)
            )
        );
    }
    test_field_sync();
    fn test_field_te1() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).te1) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings__bindgen_ty_1),
                "::",
                stringify!(te1)
            )
        );
    }
    test_field_te1();
}
impl Default for if_settings__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_if_settings() {
    assert_eq!(
        ::std::mem::size_of::<if_settings>(),
        16usize,
        concat!("Size of: ", stringify!(if_settings))
    );
    assert_eq!(
        ::std::mem::align_of::<if_settings>(),
        8usize,
        concat!("Alignment of ", stringify!(if_settings))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_size() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings),
                "::",
                stringify!(size)
            )
        );
    }
    test_field_size();
    fn test_field_ifs_ifsu() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<if_settings>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifs_ifsu) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(if_settings),
                "::",
                stringify!(ifs_ifsu)
            )
        );
    }
    test_field_ifs_ifsu();
}
impl Default for if_settings {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifreq {
    pub ifr_ifrn: ifreq__bindgen_ty_1,
    pub ifr_ifru: ifreq__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifreq__bindgen_ty_1 {
    pub ifrn_name: [::std::os::raw::c_uchar; 16usize],
}
#[test]
fn bindgen_test_layout_ifreq__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<ifreq__bindgen_ty_1>(),
        16usize,
        concat!("Size of: ", stringify!(ifreq__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<ifreq__bindgen_ty_1>(),
        1usize,
        concat!("Alignment of ", stringify!(ifreq__bindgen_ty_1))
    );
    fn test_field_ifrn_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifrn_name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_1),
                "::",
                stringify!(ifrn_name)
            )
        );
    }
    test_field_ifrn_name();
}
impl Default for ifreq__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifreq__bindgen_ty_2 {
    pub ifru_addr: sockaddr,
    pub ifru_dstaddr: sockaddr,
    pub ifru_broadaddr: sockaddr,
    pub ifru_netmask: sockaddr,
    pub ifru_hwaddr: sockaddr,
    pub ifru_flags: ::std::os::raw::c_short,
    pub ifru_ivalue: ::std::os::raw::c_int,
    pub ifru_mtu: ::std::os::raw::c_int,
    pub ifru_map: ifmap,
    pub ifru_slave: [::std::os::raw::c_char; 16usize],
    pub ifru_newname: [::std::os::raw::c_char; 16usize],
    pub ifru_data: *mut ::std::os::raw::c_void,
    pub ifru_settings: if_settings,
}
#[test]
fn bindgen_test_layout_ifreq__bindgen_ty_2() {
    assert_eq!(
        ::std::mem::size_of::<ifreq__bindgen_ty_2>(),
        24usize,
        concat!("Size of: ", stringify!(ifreq__bindgen_ty_2))
    );
    assert_eq!(
        ::std::mem::align_of::<ifreq__bindgen_ty_2>(),
        8usize,
        concat!("Alignment of ", stringify!(ifreq__bindgen_ty_2))
    );
    fn test_field_ifru_addr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_addr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_addr)
            )
        );
    }
    test_field_ifru_addr();
    fn test_field_ifru_dstaddr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_dstaddr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_dstaddr)
            )
        );
    }
    test_field_ifru_dstaddr();
    fn test_field_ifru_broadaddr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_broadaddr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_broadaddr)
            )
        );
    }
    test_field_ifru_broadaddr();
    fn test_field_ifru_netmask() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_netmask) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_netmask)
            )
        );
    }
    test_field_ifru_netmask();
    fn test_field_ifru_hwaddr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_hwaddr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_hwaddr)
            )
        );
    }
    test_field_ifru_hwaddr();
    fn test_field_ifru_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_flags) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_flags)
            )
        );
    }
    test_field_ifru_flags();
    fn test_field_ifru_ivalue() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_ivalue) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_ivalue)
            )
        );
    }
    test_field_ifru_ivalue();
    fn test_field_ifru_mtu() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_mtu) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_mtu)
            )
        );
    }
    test_field_ifru_mtu();
    fn test_field_ifru_map() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_map) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_map)
            )
        );
    }
    test_field_ifru_map();
    fn test_field_ifru_slave() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_slave) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_slave)
            )
        );
    }
    test_field_ifru_slave();
    fn test_field_ifru_newname() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_newname) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_newname)
            )
        );
    }
    test_field_ifru_newname();
    fn test_field_ifru_data() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_data) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_data)
            )
        );
    }
    test_field_ifru_data();
    fn test_field_ifru_settings() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifru_settings) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq__bindgen_ty_2),
                "::",
                stringify!(ifru_settings)
            )
        );
    }
    test_field_ifru_settings();
}
impl Default for ifreq__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_ifreq() {
    assert_eq!(
        ::std::mem::size_of::<ifreq>(),
        40usize,
        concat!("Size of: ", stringify!(ifreq))
    );
    assert_eq!(
        ::std::mem::align_of::<ifreq>(),
        8usize,
        concat!("Alignment of ", stringify!(ifreq))
    );
    fn test_field_ifr_ifrn() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifr_ifrn) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq),
                "::",
                stringify!(ifr_ifrn)
            )
        );
    }
    test_field_ifr_ifrn();
    fn test_field_ifr_ifru() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifreq>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifr_ifru) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(ifreq),
                "::",
                stringify!(ifr_ifru)
            )
        );
    }
    test_field_ifr_ifru();
}
impl Default for ifreq {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifconf {
    pub ifc_len: ::std::os::raw::c_int,
    pub ifc_ifcu: ifconf__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifconf__bindgen_ty_1 {
    pub ifcu_buf: *mut ::std::os::raw::c_char,
    pub ifcu_req: *mut ifreq,
}
#[test]
fn bindgen_test_layout_ifconf__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<ifconf__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(ifconf__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<ifconf__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(ifconf__bindgen_ty_1))
    );
    fn test_field_ifcu_buf() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifconf__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifcu_buf) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifconf__bindgen_ty_1),
                "::",
                stringify!(ifcu_buf)
            )
        );
    }
    test_field_ifcu_buf();
    fn test_field_ifcu_req() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifconf__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifcu_req) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifconf__bindgen_ty_1),
                "::",
                stringify!(ifcu_req)
            )
        );
    }
    test_field_ifcu_req();
}
impl Default for ifconf__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_ifconf() {
    assert_eq!(
        ::std::mem::size_of::<ifconf>(),
        16usize,
        concat!("Size of: ", stringify!(ifconf))
    );
    assert_eq!(
        ::std::mem::align_of::<ifconf>(),
        8usize,
        concat!("Alignment of ", stringify!(ifconf))
    );
    fn test_field_ifc_len() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifconf>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifc_len) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(ifconf),
                "::",
                stringify!(ifc_len)
            )
        );
    }
    test_field_ifc_len();
    fn test_field_ifc_ifcu() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<ifconf>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ifc_ifcu) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(ifconf),
                "::",
                stringify!(ifc_ifcu)
            )
        );
    }
    test_field_ifc_ifcu();
}
impl Default for ifconf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
